DeepSeek R1 0528

from openai import OpenAI

# Initialize the OpenAI client with Qubrid base URL
client = OpenAI(
    base_url="https://platform.qubrid.com/v1",
    api_key="QUBRID_API_KEY",
)

# Create a streaming chat completion
stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-0528",
    messages=[
      {
        "role": "user",
        "content": "Explain quantum computing in simple terms"
      }
    ],
    max_tokens=16384,
    temperature=0.6,
    top_p=0.95,
    stream=True
)

# If stream = False comment this out
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print("\n")

# If stream = True comment this out
print(stream.choices[0].message.content)

import OpenAI from 'openai';

// Initialize the OpenAI client with Qubrid base URL
const client = new OpenAI({
  baseURL: 'https://platform.qubrid.com/v1',
  apiKey: 'QUBRID_API_KEY',
});

// Create a streaming chat completion
const stream = await client.chat.completions.create({
  model: 'deepseek-ai/DeepSeek-R1-0528',
  messages: [
    {
      "role": "user",
      "content": "Explain quantum computing in simple terms"
    }
  ],
  max_tokens: 16384,
  temperature: 0.6,
  top_p: 0.95,
  stream: true
});

// If stream = false comment this out
for await (const chunk of stream) {
  if (chunk.choices[0]?.delta?.content) {
    process.stdout.write(chunk.choices[0].delta.content);
  }
}
console.log('\n');

// If stream = true comment this out
console.log(stream.choices[0].message.content);

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	url := "https://platform.qubrid.com/v1/chat/completions"

	data := map[string]interface{}{
		"model": "deepseek-ai/DeepSeek-R1-0528",
		"messages": []map[string]interface{}{
			{
				"role":    "user",
				"content": "Explain quantum computing in simple terms",
			},
		},
		"temperature": 0.6,
		"max_tokens":  16384,
		"stream":      true,
		"top_p":       0.95,
	}

	jsonData, _ := json.Marshal(data)
	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	req.Header.Set("Authorization", "Bearer QUBRID_API_KEY")
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	res, _ := client.Do(req)
	defer res.Body.Close()

	scanner := bufio.NewScanner(res.Body)
	for scanner.Scan() {
		line := scanner.Text()
		if line != "" {
			fmt.Println(line)
		}
	}
}

curl -X POST "https://platform.qubrid.com/v1/chat/completions" \
  -H "Authorization: Bearer QUBRID_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "deepseek-ai/DeepSeek-R1-0528",
  "messages": [
    {
      "role": "user",
      "content": "Explain quantum computing in simple terms"
    }
  ],
  "temperature": 0.6,
  "max_tokens": 16384,
  "stream": true,
  "top_p": 0.95
}'

<think>
The user wants a simple explanation of quantum computing.
I should cover qubits, superposition, entanglement, and practical
applications without overwhelming technical detail.
</think>

Quantum computing — simplified:

Classical computers store information as bits: 0 or 1.
Quantum computers use qubits, which can be 0, 1, or both simultaneously
(superposition) — like a coin spinning before it lands.

This lets quantum computers evaluate many possible solutions at once,
rather than sequentially — making them exponentially faster for
specific problem types.

Two key quantum properties:

  1. Superposition  — a qubit exists in multiple states at once until measured
  2. Entanglement   — two qubits can be linked so the state of one
                      instantly determines the state of the other,
                      enabling coordinated computation at massive scale

Where quantum computing matters most:
  - Cryptography (breaking and building encryption systems)
  - Drug discovery (simulating molecular structures)
  - Optimization (logistics, financial portfolio modeling)
  - Machine learning acceleration

Important caveat: quantum computers aren't replacing laptops.
They're precision instruments for problems that would take classical
supercomputers millions of years to solve.

Example: "You are an expert mathematician. Work through every problem
step by step, show all intermediate reasoning, and always verify
your answer before presenting it."